/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { menu } from '../models/menu';
import { request as __request, checkJsonSchema as __checkJsonSchema } from '../../core/request';
const schemas = require("../schema").default;

export class UserManagementService {

    /**
     * Your GET endpoint
     * 向前端提供图形验证码
     * @returns any OK
     * @throws ApiError
     */
    public static async getCaptcha({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 旧图形验证码id, 不为空表示刷新
             */
            captchaId?: string,
            /**
             * 图形高度
             */
            height?: number,
            /**
             * 图形宽度
             */
            width?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 图形验证码唯一ID
         */
        captchaId: string,
        /**
         * 图形验证码base64字符串
         */
        captcha: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/userlogin/v1/get-captcha`,
            body: requestBody,
        });

        __checkJsonSchema("getCaptcha", schemas, result);
        return result.body;
    }

    /**
     * 用户登录平台
     * @returns any OK
     * @throws ApiError
     */
    public static async userLogin({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用户登录类型:
             * account– 帐号密码登录
             * mobile– 手机号码登录
             * wechat– 微信账号登录
             */
            loginType: string,
            /**
             * 帐号密码登录参数，当用户登录类型为account时，此参数有效
             */
            accountLoginParam?: {
                /**
                 * 登录帐号
                 */
                loginname: string,
                /**
                 * 登录密码
                 */
                password: string,
                /**
                 * 认证码，防止频繁登录
                 */
                authcode?: string,
            },
            /**
             * 用户手机号码登录参数，当用户登录类型为mobile时，此参数有效
             */
            mobileLoginParams?: {
                /**
                 * 手机号码
                 */
                mobilePhone: string,
                /**
                 * 登录密码
                 */
                password: string,
                /**
                 * 短信验证码
                 */
                smsAuthCode: string,
            },
            /**
             * 微信登录参数，当用户登录类型为wechat时，此参数有效
             */
            wechatLoginParams?: any,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 账号密码输入错误剩余次数
         */
        residualTimes?: number,
        /**
         * 用户帐号对应的用户ID
         */
        userId: string,
        /**
         * 用户昵称
         */
        nickName: string,
        /**
         * 角色类型
         */
        roleType: string,
        /**
         * 登录鉴权ID
         */
        sessionId: string,
        /**
         * 用户角色的前端授权访问信息对象
         */
        roleFrontAuthInfo: {
            /**
             * 授权访问的前端系统ID
             */
            frontsysId: number,
            /**
             * 授权访问的前端系统名称
             */
            frontSysName: string,
            /**
             * 前端系统菜单信息列表
             */
            menus: Array<menu>,
        },
    }> {
        const result = await __request({
            method: 'POST',
            path: `/userlogin/v1/login`,
            body: requestBody,
        });

        // __checkJsonSchema("userLogin", schemas, result);
        return result.body;
    }

    /**
     * 用户登出平台
     * @returns any Example response
     * @throws ApiError
     */
    public static async userLogout(): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/users/v1/logout`,
        });

        __checkJsonSchema("userLogout", schemas, result);
        return result.body;
    }

    /**
     * 增加一个地区
     * @returns any OK
     * @throws ApiError
     */
    public static async addArea({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 父地区ID。如果为一级地区，则不带此参数项
             */
            parerntId?: string,
            /**
             * 父地区ID列表
             */
            parentIds?: Array<any>,
            /**
             * 地区名称
             */
            name: string,
            /**
             * 排序
             */
            sort: string,
            /**
             * 地区代码
             */
            code: string,
            /**
             * 地区类型（1：国家；2：省份、直辖市；3：地市；4：区县）
             */
            type: string,
        },
    }): Promise<{
        /**
         * 操作结果
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 地区ID
         */
        id: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/users/v1/add-area`,
            body: requestBody,
        });

        __checkJsonSchema("addArea", schemas, result);
        return result.body;
    }

    /**
     * 删除一个地区
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteArea({
        id,
        requestBody,
    }: {
        id: string,
        requestBody?: {
            /**
             * 地区ID
             */
            id: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/users/v1/delete-area/${id}`,
            body: requestBody,
        });

        __checkJsonSchema("deleteArea", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询一个地区信息
     * @returns any OK
     * @throws ApiError
     */
    public static async getArea({
        id,
        requestBody,
    }: {
        id: string,
        requestBody?: {
            /**
             * 地区ID
             */
            id: string,
        },
    }): Promise<{
        /**
         * 操作结果
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 地区名称
         */
        name: string,
        /**
         * 排序
         */
        sort: string,
        /**
         * 地区代码
         */
        code: string,
        /**
         * 地区类型（1：国家；2：省份、直辖市；3：地市；4：区县）
         */
        type: string,
        /**
         * 父级地区id
         */
        parentId: string,
        /**
         * 所有父级地区id
         */
        parentIds: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/users/v1/get-area/${id}`,
            body: requestBody,
        });

        __checkJsonSchema("getArea", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询所有地区信息
     * @returns any OK
     * @throws ApiError
     */
    public static async getListAreas(): Promise<{
        /**
         * 操作结果
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * Area对象列表
         */
        areas: Array<{
            /**
             * 父地区ID
             */
            parentId: string,
            /**
             * 父地区ID集合
             */
            parentIds: string,
            /**
             * 地区名称
             */
            name: string,
            /**
             * 排序
             */
            sort: string,
            /**
             * 地区代码
             */
            code: string,
            /**
             * 地区类型（1：国家；2：省份、直辖市；3：地市；4：区县）
             */
            type: string,
            /**
             * 地区id
             */
            id: string,
            /**
             * 子机构信息
             */
            children?: Array<any>,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/users/v1/list-areas`,
        });

        __checkJsonSchema("getListAreas", schemas, result);
        return result.body;
    }

    /**
     * 增加一个机构
     * @returns any OK
     * @throws ApiError
     */
    public static async addCompany({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 父机构ID。如果为一级地区，则不带此参数项
             */
            parentId?: string,
            /**
             * 父机构ID列表
             */
            parentIds?: Array<any>,
            /**
             * 机构名称
             */
            name: string,
            /**
             * 排序
             */
            sort: string,
            /**
             * 归属地区ID
             */
            areaId: string,
            /**
             * 机构类型（1：公司；2：部门；3：小组）
             */
            type: string,
            /**
             * 机构等级（1：一级；2：二级；3：三级；4：四级）
             */
            grade: string,
            /**
             * 机构地址
             */
            address: string,
            /**
             * 机构所在经度
             */
            longitude: string,
            /**
             * 机构所在纬度
             */
            latitude: string,
            /**
             * 机构联系人姓名
             */
            master: string,
            /**
             * 机构联系人电话
             */
            phone: string,
            /**
             * 机构联系人email
             */
            email: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 机构ID
         */
        companyId: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/users/v1/add-company`,
            body: requestBody,
        });

        __checkJsonSchema("addCompany", schemas, result);
        return result.body;
    }

    /**
     * 删除一个机构
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteCompany({
        companyId,
        requestBody,
    }: {
        companyId: string,
        requestBody?: {
            /**
             * 机构ID
             */
            companyId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/users/v1/delete-company/${companyId}`,
            body: requestBody,
        });

        __checkJsonSchema("deleteCompany", schemas, result);
        return result.body;
    }

    /**
     * 修改一个机构
     * @returns any Example response
     * @throws ApiError
     */
    public static async modCompany({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 要修改的机构ID
             */
            companyId: string,
            /**
             * 机构名称
             */
            name?: string,
            /**
             * 排序
             */
            sort?: string,
            /**
             * 归属地区ID
             */
            areaId?: string,
            /**
             * 机构类型（1：公司；2：部门；3：小组）
             */
            type?: string,
            /**
             * 机构等级（1：一级；2：二级；3：三级；4：四级）
             */
            grade?: string,
            /**
             * 机构地址
             */
            address?: string,
            /**
             * 机构所在经度
             */
            longitude?: string,
            /**
             * 机构所在纬度
             */
            latitude?: string,
            /**
             * 机构联系人姓名
             */
            master?: string,
            /**
             * 机构联系人电话
             */
            phone?: string,
            /**
             * 机构联系人 email
             */
            email?: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/users/v1/mod-company`,
            body: requestBody,
        });

        __checkJsonSchema("modCompany", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询一个机构
     * @returns any OK
     * @throws ApiError
     */
    public static async getCompany({
        companyId,
        requestBody,
    }: {
        companyId: string,
        requestBody?: {
            /**
             * 机构ID
             */
            companyId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作结果
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 机构名称
         */
        name: string,
        /**
         * 排序
         */
        sort: string,
        /**
         * 归属地区ID
         */
        areaId: string,
        /**
         * 机构类型（1：公司；2：部门；3：小组）
         */
        type: string,
        /**
         * 机构等级（1：一级；2：二级；3：三级；4：四级）
         */
        grade: string,
        /**
         * 机构地址
         */
        address: string,
        /**
         * 机构所在经度
         */
        longitude: string,
        /**
         * 机构所在纬度
         */
        latitude: string,
        /**
         * 机构联系人姓名
         */
        master: string,
        /**
         * 机构联系人电话
         */
        phone: string,
        /**
         * 机构联系人 email
         */
        email: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/users/v1/get-company/${companyId}`,
            body: requestBody,
        });

        __checkJsonSchema("getCompany", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询所有机构信息
     * @returns any OK
     * @throws ApiError
     */
    public static async getListCompanies(): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * Company对象列表
         */
        companies: Array<{
            /**
             * 父地区ID
             */
            parentId: string,
            /**
             * 父地区ID集合
             */
            parentIds: string,
            /**
             * 机构名称
             */
            name: string,
            /**
             * 排序
             */
            sort: string,
            /**
             * 归属地区ID
             */
            areaId: string,
            /**
             * 机构类型（1：公司；2：部门；3：小组）
             */
            type: string,
            /**
             * 机构等级（1：一级；2：二级；3：三级；4：四级）
             */
            grade: string,
            /**
             * 机构地址
             */
            address: string,
            /**
             * 机构所在经度
             */
            longitude: string,
            /**
             * 机构所在纬度
             */
            latitude: string,
            /**
             * 机构联系人姓名
             */
            master: string,
            /**
             * 机构联系人电话
             */
            phone: string,
            /**
             * 机构联系人email
             */
            email: string,
            /**
             * 子机构信息
             */
            children?: Array<any>,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/users/v1/list-companies`,
        });

        __checkJsonSchema("getListCompanies", schemas, result);
        return result.body;
    }

    /**
     * 增加一个角色
     * @returns any OK
     * @throws ApiError
     */
    public static async addRole({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 角色名称
             */
            name: string,
            /**
             * 角色显示名称
             */
            displayName: string,
            /**
             * 角色类型：
             * system – 系统级别角色
             * user – 用户级别角色
             */
            roleType: string,
            /**
             * 角色所归属的机构ID，如果取值为all，则为所有机构都可以用本角色；如果为特定的机构ID，则本角色仅为该机构所用
             */
            companyId: string,
            /**
             * 角色的属性定义字段，json结构。根据每个角色需求不同将该角色的所需要的属性加到这个字段中。业务系统应根据角色名称来判断这个字段中包含哪些属性key
             */
            properties: any,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 角色ID
         */
        roleId: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/users/v1/add-role`,
            body: requestBody,
        });

        __checkJsonSchema("addRole", schemas, result);
        return result.body;
    }

    /**
     * 修改一个角色
     * @returns any Example response
     * @throws ApiError
     */
    public static async modRole({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 角色ID
             */
            roleId: string,
            /**
             * 角色显示名称
             */
            displayName: string,
            /**
             * 角色的属性定义字段，json结构。根据每个角色需求不同将该角色的所需要的属性加到这个字段中。业务系统应根据角色名称来判断这个字段中包含哪些属性key
             */
            properties: any,
            /**
             * 当前本属性的用户是否可用：
             * 0 – 不可用
             * 1 – 可用
             */
            usable: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/users/v1/mod-role`,
            body: requestBody,
        });

        __checkJsonSchema("modRole", schemas, result);
        return result.body;
    }

    /**
     * 删除一个角色
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteRole({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 角色ID
             */
            roleId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/users/v1/delete-role`,
            body: requestBody,
        });

        __checkJsonSchema("deleteRole", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询一个角色信息
     * @returns any OK
     * @throws ApiError
     */
    public static async getRole({
        roleId,
        requestBody,
    }: {
        roleId: string,
        requestBody?: {
            /**
             * 角色ID
             */
            roleId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 角色名称
         */
        name: string,
        /**
         * 角色显示名称
         */
        displayName: string,
        /**
         * 角色类型：
         * system – 系统级别角色
         * user – 用户级别角色
         */
        roleType: string,
        /**
         * 角色所归属的机构ID，如果取值为all，则为所有机构都可以用本角色；如果为特定的机构ID，则本角色仅为该机构所用
         */
        companyId: string,
        /**
         * 角色的属性定义字段，json结构。根据每个角色需求不同将该角色的所需要的属性加到这个字段中。业务系统应根据角色名称来判断这个字段中包含哪些属性key
         */
        properties: any,
        /**
         * 当前本属性的用户是否可用：
         * 0 – 不可用
         * 1 – 可用
         */
        usable: number,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/users/v1/get-role/${roleId}`,
            body: requestBody,
        });

        __checkJsonSchema("getRole", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 列举角色
     * @returns any OK
     * @throws ApiError
     */
    public static async getListRoles({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 如需要根据用户ID查询其所能够归属的角色时，带此参数
             */
            userId?: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 角色对象列表
         */
        roles: Array<{
            /**
             * 值为0，操作成功
             */
            optResult: string,
            /**
             * 操作失败说明
             */
            msg?: string,
            /**
             * 角色对象列表
             */
            roles: Array<{
                /**
                 * 角色ID
                 */
                id: string,
                /**
                 * 角色名称
                 */
                name: string,
                /**
                 * 角色显示名称
                 */
                displayName: string,
                /**
                 * 角色类型：
                 * system – 系统级别角色
                 * user – 用户级别角色
                 */
                roleType: string,
            }>,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/users/v1/list-roles`,
            body: requestBody,
        });

        __checkJsonSchema("getListRoles", schemas, result);
        return result.body;
    }

    /**
     * 增加一个用户
     * @returns any Example response
     * @throws ApiError
     */
    public static async addUser({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 昵称，或者显示名称
             */
            nick_name: string,
            /**
             * 归属机构ID
             */
            companyId: string,
            /**
             * 角色ID
             */
            roleId: string,
            /**
             * 登录帐号，即登录名
             */
            login_name: string,
            /**
             * 登录密码
             */
            password: string,
            /**
             * 手机号码
             */
            mobilePhone: string,
            /**
             * 邮箱
             */
            email: string,
            /**
             * 联系地址
             */
            address: string,
            /**
             * 联系人
             */
            contactor: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 用户ID
         */
        userId: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/user/v1/add-user`,
            body: requestBody,
        });

        __checkJsonSchema("addUser", schemas, result);
        return result.body;
    }

    /**
     * 使用手机号码注册用户
     * @returns any Example response
     * @throws ApiError
     */
    public static async registerUser({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 手机号码
             */
            mobilePhone: string,
            /**
             * 登录密码,长度为6-16个字符,由字母、数字组成
             */
            password: string,
            /**
             * 短信验证码
             */
            smsAuthCode: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 用户ID
         */
        userId: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/users/v1/register-user`,
            body: requestBody,
        });

        __checkJsonSchema("registerUser", schemas, result);
        return result.body;
    }

    /**
     * 删除一个用户
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteUser({
        id,
        requestBody,
    }: {
        id: string,
        requestBody?: {
            /**
             * 用户ID
             */
            id: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/users/v1/delete-user/${id}`,
            body: requestBody,
        });

        __checkJsonSchema("deleteUser", schemas, result);
        return result.body;
    }

    /**
     * 修改一个用户信息
     * @returns any Example response
     * @throws ApiError
     */
    public static async modUser({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用户ID
             */
            userId: string,
            /**
             * 用户昵称
             */
            nick_name?: string,
            /**
             * 用户email
             */
            email?: string,
            /**
             * 用户手机号码
             */
            mobilePhone?: string,
            /**
             * 联系地址
             */
            address?: string,
            /**
             * 联系人
             */
            contactor?: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 用户ID
         */
        userId: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/users/v1/mod-user`,
            body: requestBody,
        });

        __checkJsonSchema("modUser", schemas, result);
        return result.body;
    }

    /**
     * 修改一个用户登录密码
     * @returns any Example response
     * @throws ApiError
     */
    public static async modUserPassword({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用户ID
             */
            userId: string,
            /**
             * 旧密码
             */
            oldPassword: string,
            /**
             * 新密码
             */
            newPassword: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/users/v1/mod-user-password`,
            body: requestBody,
        });

        __checkJsonSchema("modUserPassword", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询一个用户信息
     * @returns any OK
     * @throws ApiError
     */
    public static async getUserInfo({
        id,
        requestBody,
    }: {
        id: string,
        requestBody?: {
            /**
             * 用户ID
             */
            id: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 归属机构名称
         */
        companyName: string,
        /**
         * 归属机构ID
         */
        companyId: string,
        /**
         * 所属角色名称
         */
        roleName: string,
        /**
         * 所属角色类型
         */
        roleType: string,
        /**
         * 所属角色ID
         */
        roleId: string,
        /**
         * 用户昵称，或者显示名称
         */
        nick_name: string,
        /**
         * 登录名称
         */
        login_name: string,
        /**
         * 手机号码
         */
        mobile: string,
        /**
         * 邮箱
         */
        email: string,
        /**
         * 联系地址
         */
        address: string,
        /**
         * 联系人
         */
        contactor: string,
        /**
         * 是否禁用用户的一切操作,0：否，1：是
         */
        forbidden: number,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/users/v1/get-user/${id}`,
            body: requestBody,
        });

        __checkJsonSchema("getUserInfo", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询列举一批用户信息
     * @returns any OK
     * @throws ApiError
     */
    public static async getListUsers({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 要查询的用户显示名称
             */
            nick_name?: string,
            /**
             * 要查询的用户所属机构名称
             */
            companyName?: string,
            /**
             * 要查询的用户所属角色名称
             */
            roleName?: string,
            /**
             * 要查询的用户创建起始时间，格式：yyyy-MM-dd HH:mm
             */
            createTimeFrom?: string,
            /**
             * 要查询的用户创建结束时间，格式：yyyy-MM-dd HH:mm
             */
            createTimeTo?: string,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页。
             * 2）值为大于等于 1 的整数时，分页查询。
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 当前查询的页数（第几页）
         */
        pageNo?: number,
        /**
         * 总的记录条数（以便前端计算分页总数）
         */
        totalDataCount?: number,
        /**
         * User对象列表
         */
        users: Array<{
            /**
             * 用户ID
             */
            userId: string,
            /**
             * 用户显示名称
             */
            nick_name: string,
            /**
             * 所属角色名称
             */
            roleName: string,
            /**
             * 所属机构名称
             */
            companyName: string,
            /**
             * 电话
             */
            phone: string,
            /**
             * 邮箱
             */
            email?: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/users/v1/list-users`,
            body: requestBody,
        });

        __checkJsonSchema("getListUsers", schemas, result);
        return result.body;
    }

    /**
     * 向用户手机发送短信验证码
     * @returns any Example response
     * @throws ApiError
     */
    public static async sendSmsauthocde({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 发送短信验证码的用户手机
             */
            mobilePhone: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/users/v1/send-smsauthocde`,
            body: requestBody,
        });

        __checkJsonSchema("sendSmsauthocde", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 获取用户登录记录
     * @returns any OK
     * @throws ApiError
     */
    public static async getLoginRecords({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用户名
             */
            username?: string,
            /**
             * 登录结果,
             * 0 - 登录成功
             * -1 - 登录失败
             */
            result?: string,
            /**
             * 用户登录时间的查询起始时间，格式：
             * yyyy-MM-dd HH:mm:ss
             */
            loginTimeFrom?: string,
            /**
             * 用户登录时间的查询结束时间，格式：
             * yyyy-MM-dd HH:mm:ss
             */
            loginTimeTo?: string,
            /**
             * 分页查询，当前页数，默认为1
             */
            pageNum?: number,
            /**
             * 分页查询，每页记录数，默认为20
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 总记录数
         */
        totalDataCount?: number,
        /**
         * 用户登录记录
         */
        records?: Array<{
            /**
             * 用户名
             */
            username: string,
            /**
             * 用户昵称
             */
            nickname?: string,
            /**
             * 操作时间
             */
            operateTime: string,
            /**
             * 用户ip地址
             */
            ip: string,
            /**
             * 操作结果
             */
            result: {
                /**
                 * 0为操作成功
                 */
                optResult: number,
                /**
                 * 说明
                 */
                msg?: string,
            },
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/users/v1/login_records`,
            body: requestBody,
        });

        __checkJsonSchema("getLoginRecords", schemas, result);
        return result.body;
    }

    /**
     * 用户进行一些敏感的、重要的操作时，前端调用本接口以确定用户的操作行为的安全性。
     * @returns any Example response
     * @throws ApiError
     */
    public static async userloginSafeValidate({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 是否验证登录密码
             */
            isCheckPasswd: string,
            /**
             * 如果需要验证登录密码，此字段为登录密码
             */
            password?: string,
            /**
             * 认证码
             */
            captcha: string,
            /**
             * 认证码ID
             */
            captchaId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/userlogin/v1/safe-opr-validate`,
            body: requestBody,
        });

        __checkJsonSchema("userloginSafeValidate", schemas, result);
        return result.body;
    }

    /**
     * 解锁或锁定用户，不允许登录或操作
     * @returns any Example response
     * @throws ApiError
     */
    public static async usersForbidden({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 被解锁或锁定的用户id
             */
            userId: number,
            /**
             * 0:解锁用户，1：锁定用户
             */
            forbidden: number,
            /**
             * 过期时间,单位：秒，forbidden为1时有效
             */
            expire?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/users/v1/forbidden`,
            body: requestBody,
        });

        __checkJsonSchema("usersForbidden", schemas, result);
        return result.body;
    }

    /**
     * Your Post endpoint
     * 增加一个前端系统
     * @returns any Example response
     * @throws ApiError
     */
    public static async addFrontsys({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 前端系统名称
             */
            frontsysname: string,
            /**
             * 前端系统说明
             */
            description: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/menu-admin/v1/add-frontsys`,
            body: requestBody,
        });

        __checkJsonSchema("addFrontsys", schemas, result);
        return result.body;
    }

    /**
     * 删除一个前端系统
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteFrontsys({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 需要删除的前端系统名称
             */
            id: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/menu-admin/v1/del-frontsys`,
            body: requestBody,
        });

        __checkJsonSchema("deleteFrontsys", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 列举所有前端系统
     * @returns any OK
     * @throws ApiError
     */
    public static async getListFrontsys(): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 前端系统对象列表
         */
        fs?: Array<{
            /**
             * 前端系统ID号
             */
            id: string,
            /**
             * 前端系统名称
             */
            frontsysname: string,
            /**
             * 前端系统说明
             */
            description: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/menu-admin/v1/list-frontsys`,
        });

        __checkJsonSchema("getListFrontsys", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询一个前端系统详细信息
     * @returns any OK
     * @throws ApiError
     */
    public static async getFrontsys({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 查询的ID
             */
            id: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 前端系统基础信息
         */
        baseInfo: {
            /**
             * 前端系统名称
             */
            frontsysname: string,
            /**
             * 前端系统说明
             */
            description: string,
        },
        /**
         * 前端系统菜单信息列表
         */
        menus: Array<{
            /**
             * 菜单项ID号
             */
            id: string,
            /**
             * 菜单项名称
             */
            menuname: string,
            /**
             * 菜单项访问uri路径
             */
            uri: string,
            /**
             * 本菜单项下子菜单对象列表
             */
            menus?: Array<any>,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/menu-admin/v1/get-frontsys`,
            body: requestBody,
        });

        __checkJsonSchema("getFrontsys", schemas, result);
        return result.body;
    }

    /**
     * 向一个前端系统增加一个菜单项
     * @returns any Example response
     * @throws ApiError
     */
    public static async addMenuitem({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 前端系统ID号
             */
            frontsysId: string,
            /**
             * 添加菜单项的父菜单ID号，如果是顶级菜单，则此项值为0
             */
            parentId: number,
            /**
             * 菜单项名称
             */
            menuname: string,
            /**
             * 菜单项访问uri路径
             */
            uri: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/menu-admin/v1/add-menuitem`,
            body: requestBody,
        });

        __checkJsonSchema("addMenuitem", schemas, result);
        return result.body;
    }

    /**
     * 修改一个菜单项信息
     * @returns any Example response
     * @throws ApiError
     */
    public static async modMenuitem({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 需要修改的菜单项ID号
             */
            id: string,
            /**
             * 菜单项名称
             */
            menuname?: string,
            /**
             * 菜单项访问uri路径
             */
            uri?: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/menu-admin/v1/mod-menuitem`,
            body: requestBody,
        });

        __checkJsonSchema("modMenuitem", schemas, result);
        return result.body;
    }

    /**
     * 删除一个菜单项信息
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteMenuitem({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 需要删除的菜单项ID号
             */
            id: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/menu-admin/v1/del-menuitem`,
            body: requestBody,
        });

        __checkJsonSchema("deleteMenuitem", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询一个角色当前对前端系统菜单的访问权限
     * @returns any OK
     * @throws ApiError
     */
    public static async getRoleAccess({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 要查询的用户角色ID号
             */
            userRoleId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 用户角色的前端授权访问信息对象
         */
        roleFrontAuthInfo: {
            /**
             * 授权访问的前端系统ID
             */
            frontsysId: number,
            /**
             * 授权访问的前端系统名称
             */
            frontSysName: string,
            /**
             * 前端系统菜单信息列表
             */
            menus: Array<menu>,
        },
    }> {
        const result = await __request({
            method: 'GET',
            path: `/role-auth-ctrl/v1/get-frontauth`,
            body: requestBody,
        });

        __checkJsonSchema("getRoleAccess", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询一个角色对前端系统菜单的访问可供选择的权限列表
     * @returns any OK
     * @throws ApiError
     */
    public static async getRoleListAccess({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 要查询的用户角色ID号
             */
            userRoleId: string,
            /**
             * 要查询的前端系统ID号
             */
            frontsysId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 前端系统菜单信息列表
         */
        menus: Array<{
            /**
             * 菜单项ID号
             */
            id: number,
            /**
             * 菜单项的父菜单ID号，如果为顶级菜单则此项值为0
             */
            parentId: number,
            /**
             * 菜单项名称
             */
            menuname: string,
            /**
             * 菜单项访问uri路径
             */
            uri: string,
            /**
             * 本菜单项下子菜单对象列表
             */
            menus?: Array<any>,
            /**
             * 该菜单项当前是否授权给该角色，取值：0-未授权；1-已授权
             */
            isAuth: number,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/role-auth-ctrl/v1/get-frontauth-manalist`,
            body: requestBody,
        });

        __checkJsonSchema("getRoleListAccess", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 修改一个角色对前端系统菜单的访问权限
     * @returns any Example response
     * @throws ApiError
     */
    public static async modRoleAccess({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 要修改的用户角色ID号
             */
            userRoleId: string,
            /**
             * 用户角色的前端授权访问信息对象
             */
            roleFrontAuthInfo: {
                /**
                 * 授权访问的前端系统ID
                 */
                frontsysId: number,
                /**
                 * 授权访问的前端系统名称
                 */
                frontSysName: string,
                /**
                 * 前端系统菜单信息列表
                 */
                menus: Array<menu>,
            },
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/role-auth-ctrl/v1/mod-frontauth`,
            body: requestBody,
        });

        __checkJsonSchema("modRoleAccess", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询一个角色当前的Api访问权限
     * @returns any OK
     * @throws ApiError
     */
    public static async getApiauth({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 要查询的用户角色ID号
             */
            userRoleId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 用户角色的Api访问信息对象列表
         */
        roleApiAuthInfos: Array<{
            /**
             * 授权访问的Api暴露目标类型，取值为：
             * apiinvoker - 此Api暴露给第三方调用者；
             * apigateway - 此Api暴露给Api网关
             * frontend - 此Api暴露给前端
             * fixexternal - 此api暴露给固定外部服务
             */
            type: number,
            /**
             * 授权访问的Api信息对象列表
             */
            apis: Array<{
                /**
                 * Api操作对象ID
                 */
                apiOprId: string,
                /**
                 * 授权访问的Api信息对象列表
                 */
                apiName: string,
                /**
                 * 授权访问的Api信息对象版本号
                 */
                version: number,
                /**
                 * 授权访问的Api信息对象访问路径
                 */
                uri: string,
                /**
                 * 授权访问的该Api的方法对象列表
                 */
                methods: Array<any>,
            }>,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/role-auth-ctrl/v1/get-apiauth`,
            body: requestBody,
        });

        __checkJsonSchema("getApiauth", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查询一个角色对Api的访问权限列表
     * @returns any OK
     * @throws ApiError
     */
    public static async getApiauthList({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 要查询的用户角色ID号
             */
            userRoleId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 用户角色的Api访问信息对象列表
         */
        roleApiAuthInfos: Array<{
            /**
             * 授权访问的Api暴露目标类型，取值为：
             * apiinvoker - 此Api暴露给第三方调用者；
             * apigateway - 此Api暴露给Api网关
             * frontend - 此Api暴露给前端
             * fixexternal - 此api暴露给固定外部服务
             */
            type: number,
            /**
             * 授权访问的Api信息对象列表
             */
            apis: Array<{
                /**
                 * Api操作对象ID
                 */
                apiOprId: string,
                /**
                 * 授权访问的Api信息对象列表
                 */
                apiName: string,
                /**
                 * 授权访问的Api信息对象版本号
                 */
                version: number,
                /**
                 * 授权访问的Api信息对象访问路径
                 */
                uri: string,
                /**
                 * 授权访问的该Api的方法对象列表
                 */
                methods: Array<{
                    /**
                     * Api方法名称
                     */
                    method: string,
                    /**
                     * 该Api方法是否被授权，取值：
                     * 0-非授权；1-授权
                     */
                    isAuth: number,
                }>,
                /**
                 * 该Api是否被授权，取值：
                 * 0-非授权；1-授权
                 */
                isAuth: number,
            }>,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/role-auth-ctrl/v1/get-apiauth-manalist`,
            body: requestBody,
        });

        __checkJsonSchema("getApiauthList", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 修改一个角色对Api的访问权限
     * @returns any Example response
     * @throws ApiError
     */
    public static async modApiauth({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 要查询的用户角色ID号
             */
            userRoleId: string,
            /**
             * 操作类型：
             * mod – 修改该Api授权；
             * del – 取消该Api授权；
             */
            oprType: string,
            /**
             * 需要操作的Api操作ID号
             */
            apiOprId: string,
            /**
             * Api名称。如果oprType为mod，且为该角色新增授权该Api的时候，需要此字段
             */
            apiName?: string,
            /**
             * Api版本。如果oprType为mod，且为该角色新增授权该Api的时候，需要此字段
             */
            version?: number,
            /**
             * Api操作uri。如果oprType为mod，且为该角色新增授权该Api的时候，需要此字段
             */
            uri?: string,
            /**
             * 需要授权的该Api的操作方法列表，当oprType为mod时带此参数
             */
            methods?: Array<any>,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/role-auth-ctrl/v1/mod-apiauth`,
            body: requestBody,
        });

        __checkJsonSchema("modApiauth", schemas, result);
        return result.body;
    }

}